""" 1.遍历当目录和子目录下的头文件，从头文件中获取类名以及父类和继承方式，成员变量以及成员变量的类型，成员函数以及成员函数的参数和返回值
    2.把类名，父类名，继承方式做成一个2行3列的word表格
"""

import os
import re
import docx

def get_class_name(content):
    """ 获取类名 """
    class_name = re.findall(r"class\s+(\w+)\s*:", content)
    class_name2 = re.findall(r"class\s+(\w+)\s*:\s*\w+\s+\w+", content)
    return class_name

def get_class_parent(content):
    """ 获取父类 """
    parent_class_name = re.findall(r"class\s+(\w+)\s*:\s*\w+\s+\w+", content)
    return parent_class_name

def get_class_parent_type(content):
    """ 获取继承方式 """
    class_parent_type = re.findall(r"class\s+\w+\s*:\s*(\w+)\s+\w+", content)
    return class_parent_type

def get_private_members(content):
    """ 获取私有成员变量 """
    private_members = re.findall(r"private:\s*(\w+\s+\w+;)", content)
    return private_members

def get_public_methods(content):
    """ 获取共有成员函数 """
    public_methods = re.findall(r"public:\s*(\w+\s+\w+\(.*\);)", content)
    return public_methods

def get_members_type(content):
    """ 获取成员变量的类型 """
    members_type = re.findall(r"(\w+)\s+\w+;", content)
    return members_type

def get_methods_params(content):
    """ 获取成员函数的参数 """
    methods_params = re.findall(r"\w+\s+\w+\((.*)\);", content)
    return methods_params

def get_methods_return(content):
    """ 获取成员函数的返回值 """
    methods_return = re.findall(r"\w+\s+(\w+)\s*\(", content)
    return methods_return

def get_methods_params_type(content):
    """ 获取成员函数的参数类型 """
    methods_params_type = re.findall(r"(\w+)\s+\w+", content)
    return methods_params_type

def get_methods_params_name(content):
    """ 获取成员函数的参数名 """
    methods_params_name = re.findall(r"\w+\s+(\w+)", content)
    return methods_params_name

def get_methods_return_type(content):
    """ 获取成员函数的返回值类型 """
    methods_return_type = re.findall(r"(\w+)\s+\w+\s*\(", content)
    return methods_return_type

def get_class_info(file):
    """ 获取类的信息 """
    # 获取文件名
    file_name = os.path.splitext(file)[0]
    # 获取文件后缀
    file_ext = os.path.splitext(file)[1]
    # 判断文件后缀是否为.h
    if file_ext == '.h':
        # 读取文件内容
        with open(file, 'r') as f:
            content = f.read()
            # 获取类名
            class_name = get_class_name(content)
            # 获取父类名
            parent_class_name = get_class_parent(content)
            # 获取继承方式
            class_parent_type = get_class_parent_type(content)
            # 获取私有成员变量
            private_members = get_private_members(content)
            # 获取共有成员函数
            public_methods = get_public_methods(content)
            # 获取成员变量的类型
            members_type = get_members_type(content)
            # 获取成员函数的参数
            methods_params = get_methods_params(content)
            # 获取成员函数的返回值
            methods_return = get_methods_return(content)
            # 获取成员函数的参数类型
            methods_params_type = get_methods_params_type(content)
            # 获取成员函数的参数名
            methods_params_name = get_methods_params_name(content)
            # 获取成员函数的返回值类型
            methods_return_type = get_methods_return_type(content)
            # 打印类名
            print('类名:', class_name)
            # 打印父类名
            print('父类名:', parent_class_name)
            # 打印继承方式
            print('继承方式:', class_parent_type)
            # 打印私有成员变量
            print('私有成员变量:', private_members)
            # 打印共有成员函数
            print('共有成员函数:', public_methods)
            # 打印成员变量的类型
            print('成员变量的类型:', members_type)
            # 打印成员函数的参数
            print('成员函数的参数:', methods_params)
            # 打印成员函数的返回值
            print('成员函数的返回值:', methods_return)
            # 打印成员函数的参数类型

            print('成员函数的参数类型:', methods_params_type)
            # 打印成员函数的参数名
            print('成员函数的参数名:', methods_params_name)
            # 打印成员函数的返回值类型
            print('成员函数的返回值类型:', methods_return_type)
            # 创建word文档
            doc = docx.Document()
            # 添加标题
            doc.add_heading(file_name, 0)
            # 添加表格
            table = doc.add_table(rows=2, cols=3)
            # 添加表格内容
            table.cell(0, 0).text = '类名'
            table.cell(0, 1).text = '父类名'
            table.cell(0, 2).text = '继承方式'
            table.cell(1, 0).text = class_name[0]
            table.cell(1, 1).text = parent_class_name[0]
            table.cell(1, 2).text = class_parent_type[0]
            # 添加表格
            table = doc.add_table(rows=2, cols=3)
            # 添加表格内容
            table.cell(0, 0).text = '私有成员变量'
            table.cell(0, 1).text = '共有成员函数'
            table.cell(0, 2).text = '成员变量的类型'
            table.cell(1, 0).text = str(private_members)
            table.cell(1, 1).text = str(public_methods)
            table.cell(1, 2).text = str(members_type)
            # 添加表格
            table = doc.add_table(rows=2, cols=3)
            # 添加表格内容
            table.cell(0, 0).text = '成员函数的参数'
            table.cell(0, 1).text = '成员函数的返回值'
            table.cell(0, 2).text = '成员函数的参数类型'
            table.cell(1, 0).text = str(methods_params)
            table.cell(1, 1).text = str(methods_return)
            table.cell(1, 2).text = str(methods_params_type)
            # 添加表格
            table = doc.add_table(rows=2, cols=3)
            # 添加表格内容
            table.cell(0, 0).text = '成员函数的参数名'
            table.cell(0, 1).text = '成员函数的返回值类型'
            table.cell(1, 0).text = str(methods_params_name)
            table.cell(1, 1).text = str(methods_return_type)
            # 保存word文档
            doc.save(file_name + '.docx')

if __name__ == '__main__':
    # 获取当前目录下的所有文件
    files = os.listdir(os.getcwd())
    # 遍历文件
    for file in files:
        # 获取文件后缀
        file_ext = os.path.splitext(file)[1]
        # 判断文件后缀是否为.h
        if file_ext == '.h':
            # 获取类的信息
            get_class_info(file)

